const WebSocket = require('ws');
const http = require('http');

// 创建HTTP服务器
const server = http.createServer();

// 创建WebSocket服务器
const wss = new WebSocket.Server({ server });

// 存储连接的客户端
const clients = new Set();

console.log('WebSocket服务器启动在 ws://localhost:8080');

wss.on('connection', (ws) => {
  console.log('新客户端连接');
  clients.add(ws);
  
  // 发送欢迎消息
  ws.send(JSON.stringify({
    type: 'system',
    content: '欢迎使用WebSocket聊天服务器！'
  }));
  
  ws.on('message', (message) => {
    try {
      const data = JSON.parse(message);
      console.log('收到消息:', data);
      
      if (data.type === 'message') {
        // 模拟处理用户消息并返回多条回复
        simulateResponse(ws, data.content);
      } else if (data.type === 'request_data') {
        // 处理数据请求
        sendTableData(ws, data.content, data.sessionId);
      }
    } catch (error) {
      console.error('解析消息失败:', error);
      ws.send(JSON.stringify({
        type: 'error',
        content: '消息格式错误'
      }));
    }
  });
  
  ws.on('close', () => {
    console.log('客户端断开连接');
    clients.delete(ws);
  });
  
  ws.on('error', (error) => {
    console.error('WebSocket错误:', error);
    clients.delete(ws);
  });
});

// 模拟服务器响应函数
function simulateResponse(ws, userMessage) {
  // 模拟不同的回复内容
  const responses = [
    `我收到了您的消息: "${userMessage}"`,
    `这是一个关于"${userMessage}"的详细回复`,
    `针对"${userMessage}"，我还有另一个建议`
  ];
  
  // 随机决定返回1-3条回复
  const responseCount = Math.floor(Math.random() * 3) + 1;
  const selectedResponses = responses.slice(0, responseCount);
  
  console.log(`将发送 ${responseCount} 条回复`);
  
  // 逐条发送回复，模拟真实的对话场景
  selectedResponses.forEach((response, index) => {
    setTimeout(() => {
      if (ws.readyState === WebSocket.OPEN) {
        const isLast = index === responseCount - 1;
        ws.send(JSON.stringify({
          type: 'response',
          content: response,
          messageId: Date.now() + index,
          isLast: isLast
        }));
        console.log(`发送回复 ${index + 1}: ${response}${isLast ? ' (最后一条)' : ''}`);
        
        // 如果是最后一条消息，只发送完成信号，不再自动发送数据
        if (isLast) {
          setTimeout(() => {
            if (ws.readyState === WebSocket.OPEN) {
              // 发送完成信号
              ws.send(JSON.stringify({
                type: 'complete',
                content: '所有回复已发送完成'
              }));
              console.log('发送完成信号');
            }
          }, 500);
        }
      }
    }, (index + 1) * 1000); // 每条回复间隔1秒
  });
}

// 存储会话数据的映射表
const sessionDataMap = new Map();

// 发送表格数据函数
function sendTableData(ws, requestContent, sessionId) {
  console.log('收到数据请求，发送表格数据...会话ID:', sessionId);
  
  if (ws.readyState === WebSocket.OPEN) {
    // 检查是否已有该会话的数据
    let mockTableData;
    
    if (sessionDataMap.has(sessionId)) {
      // 使用已存储的数据
      mockTableData = sessionDataMap.get(sessionId);
      console.log('使用已存储的会话数据');
    } else {
      // 为新会话生成数据
      mockTableData = [
        {
          id: '1',
          name: `会话${sessionId.slice(-4)}的分析结果1`,
          value: Math.floor(Math.random() * 1000),
          category: '类别A',
          status: '正常',
          date: new Date().toLocaleDateString()
        },
        {
          id: '2',
          name: `会话${sessionId.slice(-4)}的分析结果2`,
          value: Math.floor(Math.random() * 1000),
          category: '类别B',
          status: '异常',
          date: new Date().toLocaleDateString()
        },
        {
          id: '3',
          name: `会话${sessionId.slice(-4)}的分析结果3`,
          value: Math.floor(Math.random() * 1000),
          category: '类别A',
          status: '正常',
          date: new Date().toLocaleDateString()
        },
        {
          id: '4',
          name: `会话${sessionId.slice(-4)}的分析结果4`,
          value: Math.floor(Math.random() * 1000),
          category: '类别C',
          status: '警告',
          date: new Date().toLocaleDateString()
        }
      ];
      
      // 存储会话数据
      sessionDataMap.set(sessionId, mockTableData);
      console.log('已生成并存储新的会话数据');
    }
    
    ws.send(JSON.stringify({
      type: 'data',
      content: mockTableData,
      sessionId: sessionId
    }));
    
    console.log('已发送表格数据:', mockTableData.length, '条');
  }
}

// 处理服务器错误
server.on('error', (error) => {
  console.error('服务器错误:', error);
});

// 启动服务器
server.listen(8080, () => {
  console.log('服务器正在监听端口 8080');
});

// 优雅关闭
process.on('SIGINT', () => {
  console.log('\n正在关闭服务器...');
  
  // 关闭所有客户端连接
  clients.forEach(ws => {
    if (ws.readyState === WebSocket.OPEN) {
      ws.close();
    }
  });
  
  // 关闭服务器
  server.close(() => {
    console.log('服务器已关闭');
    process.exit(0);
  });
});

process.on('SIGTERM', () => {
  console.log('\n收到SIGTERM信号，正在关闭服务器...');
  
  // 关闭所有客户端连接
  clients.forEach(ws => {
    if (ws.readyState === WebSocket.OPEN) {
      ws.close();
    }
  });
  
  // 关闭服务器
  server.close(() => {
    console.log('服务器已关闭');
    process.exit(0);
  });
});